#!/usr/bin/env python
# -*- coding: utf-8 -*-

'''
@File    : json_handler.py
@Description : JSON处理模块，用于读取和处理JSON格式的测试数据
'''

import os
import json
from typing import Dict, List, Any, Optional, Union

# 导入配置和日志
from config.settings import config
from utils.log_handler import get_logger


class JsonHandler:
    """
    JSON处理类，用于读取和处理JSON格式的测试数据
    """
    def __init__(self, file_path: str = None):
        """
        初始化JSON处理类
        
        Args:
            file_path: JSON文件路径，默认为None，使用默认测试数据文件路径
        """
        self.logger = get_logger("json_handler")
        
        # 如果未指定文件路径，使用默认测试数据文件路径
        if file_path is None:
            self.file_path = os.path.join(config.data_dir, 'sample_data.json')
        else:
            self.file_path = file_path
        
        self.logger.info(f"JSON文件路径: {self.file_path}")
        
        # 检查文件是否存在
        if not os.path.exists(self.file_path):
            self.logger.warning(f"JSON文件不存在: {self.file_path}，将创建新文件")
            self._create_default_json()
        
        # 读取JSON数据
        self.data = self._read_json()
    
    def _create_default_json(self) -> None:
        """
        创建默认的JSON测试数据文件
        """
        # 创建默认数据
        default_data = {
            "test_cases": [
                {
                    "用例ID": "TC001",
                    "模块": "用户管理",
                    "用例名称": "获取用户列表",
                    "前置条件": "",
                    "请求方法": "GET",
                    "请求URL": "/api/users",
                    "请求头": {"Content-Type": "application/json"},
                    "请求参数": {"page": 1, "size": 10},
                    "请求体": "",
                    "预期状态码": 200,
                    "预期结果": {"code": 0, "message": "success"},
                    "是否执行": "Y"
                }
            ],
            "test_data": [
                {
                    "数据ID": "D001",
                    "用例ID": "TC001",
                    "数据名称": "用户名",
                    "数据值": "admin"
                }
            ]
        }
        
        # 确保目录存在
        os.makedirs(os.path.dirname(self.file_path), exist_ok=True)
        
        # 写入JSON文件
        with open(self.file_path, 'w', encoding='utf-8') as f:
            json.dump(default_data, f, ensure_ascii=False, indent=2)
        
        self.logger.info(f"已创建默认JSON测试数据文件: {self.file_path}")
    
    def _read_json(self) -> Dict[str, Any]:
        """
        读取JSON文件
        
        Returns:
            JSON数据字典
        """
        try:
            with open(self.file_path, 'r', encoding='utf-8') as f:
                data = json.load(f)
            self.logger.info(f"成功读取JSON文件: {self.file_path}")
            return data
        except Exception as e:
            self.logger.error(f"读取JSON文件失败: {str(e)}")
            return {"test_cases": [], "test_data": []}
    
    def _write_json(self, data: Dict[str, Any]) -> bool:
        """
        写入JSON文件
        
        Args:
            data: 要写入的JSON数据
            
        Returns:
            写入结果，True表示成功，False表示失败
        """
        try:
            with open(self.file_path, 'w', encoding='utf-8') as f:
                json.dump(data, f, ensure_ascii=False, indent=2)
            self.logger.info(f"成功写入JSON文件: {self.file_path}")
            return True
        except Exception as e:
            self.logger.error(f"写入JSON文件失败: {str(e)}")
            return False
    
    def get_test_cases(self, filter_enabled: bool = True) -> List[Dict[str, Any]]:
        """
        获取测试用例数据
        
        Args:
            filter_enabled: 是否只返回启用的测试用例，默认为True
            
        Returns:
            测试用例数据列表
        """
        test_cases = self.data.get("test_cases", [])
        
        # 如果需要过滤，只返回启用的测试用例
        if filter_enabled:
            test_cases = [case for case in test_cases if case.get("是否执行") == "Y"]
        
        return test_cases
    
    def get_test_data(self, case_id: str = None) -> List[Dict[str, Any]]:
        """
        获取测试数据
        
        Args:
            case_id: 测试用例ID，如果指定，则只返回该测试用例的测试数据
            
        Returns:
            测试数据列表
        """
        test_data = self.data.get("test_data", [])
        
        # 如果指定了测试用例ID，则只返回该测试用例的测试数据
        if case_id:
            test_data = [data for data in test_data if data.get("用例ID") == case_id]
        
        return test_data
    
    def add_test_case(self, test_case: Dict[str, Any]) -> bool:
        """
        添加测试用例
        
        Args:
            test_case: 测试用例数据
            
        Returns:
            添加结果，True表示成功，False表示失败
        """
        try:
            # 检查测试用例ID是否已存在
            case_id = test_case.get("用例ID")
            if not case_id:
                self.logger.error("测试用例ID不能为空")
                return False
            
            # 检查测试用例ID是否已存在
            existing_cases = [case for case in self.data.get("test_cases", []) if case.get("用例ID") == case_id]
            if existing_cases:
                self.logger.error(f"测试用例ID已存在: {case_id}")
                return False
            
            # 添加测试用例
            self.data.setdefault("test_cases", []).append(test_case)
            
            # 写入JSON文件
            result = self._write_json(self.data)
            if result:
                self.logger.info(f"成功添加测试用例: {case_id}")
            return result
        except Exception as e:
            self.logger.error(f"添加测试用例失败: {str(e)}")
            return False
    
    def add_test_data(self, test_data: Dict[str, Any]) -> bool:
        """
        添加测试数据
        
        Args:
            test_data: 测试数据
            
        Returns:
            添加结果，True表示成功，False表示失败
        """
        try:
            # 检查数据ID是否已存在
            data_id = test_data.get("数据ID")
            if not data_id:
                self.logger.error("数据ID不能为空")
                return False
            
            # 检查数据ID是否已存在
            existing_data = [data for data in self.data.get("test_data", []) if data.get("数据ID") == data_id]
            if existing_data:
                self.logger.error(f"数据ID已存在: {data_id}")
                return False
            
            # 添加测试数据
            self.data.setdefault("test_data", []).append(test_data)
            
            # 写入JSON文件
            result = self._write_json(self.data)
            if result:
                self.logger.info(f"成功添加测试数据: {data_id}")
            return result
        except Exception as e:
            self.logger.error(f"添加测试数据失败: {str(e)}")
            return False
    
    def update_test_case(self, case_id: str, test_case: Dict[str, Any]) -> bool:
        """
        更新测试用例
        
        Args:
            case_id: 测试用例ID
            test_case: 测试用例数据
            
        Returns:
            更新结果，True表示成功，False表示失败
        """
        try:
            # 查找测试用例
            test_cases = self.data.get("test_cases", [])
            for i, case in enumerate(test_cases):
                if case.get("用例ID") == case_id:
                    # 更新测试用例
                    test_cases[i] = test_case
                    
                    # 写入JSON文件
                    result = self._write_json(self.data)
                    if result:
                        self.logger.info(f"成功更新测试用例: {case_id}")
                    return result
            
            self.logger.error(f"测试用例不存在: {case_id}")
            return False
        except Exception as e:
            self.logger.error(f"更新测试用例失败: {str(e)}")
            return False
    
    def update_test_data(self, data_id: str, test_data: Dict[str, Any]) -> bool:
        """
        更新测试数据
        
        Args:
            data_id: 数据ID
            test_data: 测试数据
            
        Returns:
            更新结果，True表示成功，False表示失败
        """
        try:
            # 查找测试数据
            test_data_list = self.data.get("test_data", [])
            for i, data in enumerate(test_data_list):
                if data.get("数据ID") == data_id:
                    # 更新测试数据
                    test_data_list[i] = test_data
                    
                    # 写入JSON文件
                    result = self._write_json(self.data)
                    if result:
                        self.logger.info(f"成功更新测试数据: {data_id}")
                    return result
            
            self.logger.error(f"测试数据不存在: {data_id}")
            return False
        except Exception as e:
            self.logger.error(f"更新测试数据失败: {str(e)}")
            return False
    
    def delete_test_case(self, case_id: str) -> bool:
        """
        删除测试用例
        
        Args:
            case_id: 测试用例ID
            
        Returns:
            删除结果，True表示成功，False表示失败
        """
        try:
            # 查找测试用例
            test_cases = self.data.get("test_cases", [])
            for i, case in enumerate(test_cases):
                if case.get("用例ID") == case_id:
                    # 删除测试用例
                    del test_cases[i]
                    
                    # 写入JSON文件
                    result = self._write_json(self.data)
                    if result:
                        self.logger.info(f"成功删除测试用例: {case_id}")
                    return result
            
            self.logger.error(f"测试用例不存在: {case_id}")
            return False
        except Exception as e:
            self.logger.error(f"删除测试用例失败: {str(e)}")
            return False
    
    def delete_test_data(self, data_id: str) -> bool:
        """
        删除测试数据
        
        Args:
            data_id: 数据ID
            
        Returns:
            删除结果，True表示成功，False表示失败
        """
        try:
            # 查找测试数据
            test_data_list = self.data.get("test_data", [])
            for i, data in enumerate(test_data_list):
                if data.get("数据ID") == data_id:
                    # 删除测试数据
                    del test_data_list[i]
                    
                    # 写入JSON文件
                    result = self._write_json(self.data)
                    if result:
                        self.logger.info(f"成功删除测试数据: {data_id}")
                    return result
            
            self.logger.error(f"测试数据不存在: {data_id}")
            return False
        except Exception as e:
            self.logger.error(f"删除测试数据失败: {str(e)}")
            return False
    
    def write_result(self, case_id: str, result: str, status: str) -> bool:
        """
        写入测试结果
        
        Args:
            case_id: 测试用例ID
            result: 测试结果
            status: 测试状态，如通过、失败等
            
        Returns:
            写入结果，True表示成功，False表示失败
        """
        try:
            # 查找测试用例
            test_cases = self.data.get("test_cases", [])
            for i, case in enumerate(test_cases):
                if case.get("用例ID") == case_id:
                    # 更新测试结果
                    test_cases[i]["测试结果"] = result
                    test_cases[i]["测试状态"] = status
                    
                    # 写入JSON文件
                    result = self._write_json(self.data)
                    if result:
                        self.logger.info(f"成功写入测试结果，用例ID: {case_id}, 结果: {result}, 状态: {status}")
                    return result
            
            self.logger.error(f"测试用例不存在: {case_id}")
            return False
        except Exception as e:
            self.logger.error(f"写入测试结果失败: {str(e)}")
            return False


if __name__ == '__main__':
    # 测试JSON处理类
    handler = JsonHandler()
    # 读取测试用例
    test_cases = handler.get_test_cases()
    print(f"测试用例数量: {len(test_cases)}")
    # 读取测试数据
    test_data = handler.get_test_data()
    print(f"测试数据数量: {len(test_data)}")